package com.augurit.common.system.service.org.impl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springside.modules.orm.Page;

import com.augurit.common.base.form.ResultForm;
import com.augurit.common.constant.OrgConstant;
import com.augurit.common.dao.AcPartyRoleDao;
import com.augurit.common.dao.AcRoleDao;
import com.augurit.common.dao.OmGroupDao;
import com.augurit.common.dao.OmOrgDao;
import com.augurit.common.dao.OmPositionDao;
import com.augurit.common.dao.OmUserDao;
import com.augurit.common.dao.OmUserPositionDao;
import com.augurit.common.entity.OmGroup;
import com.augurit.common.entity.OmOrg;
import com.augurit.common.entity.OmPosition;
import com.augurit.common.entity.OmUserPosition;
import com.augurit.common.syscode.service.ISysCodeService;
import com.augurit.common.syscode.web.form.SysCodeForm;
import com.augurit.common.system.convert.OmPositionConverter;
import com.augurit.common.system.service.org.IOmPositionService;
import com.augurit.common.system.service.org.IOmUserService;
import com.augurit.common.system.util.MsgUtils;
import com.augurit.common.system.util.OrgUtils;
import com.augurit.common.system.web.org.form.AcRoleForm;
import com.augurit.common.system.web.org.form.OmOrgForm;
import com.augurit.common.system.web.org.form.OmPositionForm;
import com.augurit.common.system.web.org.form.OmUserForm;
import com.augurit.common.util.HqlUtils;
import com.augurit.common.util.PageUtils;
import com.augurit.common.util.lang.CollectionUtils;

/**
 * 岗位逻辑实现类
 */
@Service
@Transactional
public class OmPositionServiceImpl implements IOmPositionService {

	// DAO 引用
	@Autowired
	private OmPositionDao omPositionDao;

	@Autowired
	private OmUserPositionDao omUserPositionDao;

	@Autowired
	private AcPartyRoleDao partyRoleDao;
	
	@Autowired 
	private OmGroupDao omGroupDao;
	
	@Autowired
	private OmUserDao omUserDao;

	@Autowired
	private OmOrgDao omOrgDao;
	
	@Autowired
	private AcRoleDao acRoleDao;

	@Autowired
	private ISysCodeService sysCodeService;
	
	@Autowired
	private IOmUserService omUserService;
	/**
	 * 根据ID岗位Form对象
	 * @param id 岗位主键ID
	 * @return 岗位Form对象
	 */
	@Transactional(readOnly = true)
	public OmPositionForm get(Long id) {
		//获取岗位form对象
		OmPositionForm form =omPositionDao.getForm(id);

		//加载其他扩展属性
		form.setParentPosName(omPositionDao.getParentPosName(id));

		if(form.getPosType().equals(OrgConstant.PARTY_TYPE_ORG))
			form.setOrgName(omOrgDao.getOrgName(form.getPartyId()));
		else
			form.setGroupName(omGroupDao.getGroupName(form.getPartyId()));
		
		return form;
	}

	/**
	 * 保存岗位Form对象数组
	 * @param forms 岗位Form对象或对象数组
	 */
	public void save(OmPositionForm... forms) {
		if (forms != null)
			for (OmPositionForm form : forms)
				omPositionDao.save(form);
	}

	/**
	 * 根据主键ID集合删除多个岗位对象
	 * 
	 * @param ids 岗位主键或主键数组
	 */
	public void delete(Long... ids) {
		if (ids != null)
			omPositionDao.delete(ids);
	}

	@Transactional(readOnly = true)
	public List<OmPositionForm> getPositionsByCodeList(List<String> posCodeList){
		if(posCodeList != null && posCodeList.size() > 0){
			String hql = "from OmPosition ps where " + HqlUtils.buildOrCondition("ps", "posCode", CollectionUtils.toStringArray(posCodeList));
			List<OmPosition> list = omPositionDao.find(hql);
			return OmPositionConverter.convertToFormList(list);
		}else
			return null;
	}
	
	/**
	 * 根据机构主键查询直属下级岗位
	 * @param OrgId 机构主键
	 * @return 机构主键查询下级岗位对象主键的集合
	 */
	@Transactional(readOnly = true)
	public List<Long> getPositionIdsByOrgId(Long orgId) {
		if (orgId != null)
			return omPositionDao.getPositionIds(OrgConstant.PARTY_TYPE_ORG,orgId);
		else
			return null;
	}
	
	/**
	 * 根据工作组主键查询直属下级岗位
	 * @param groupId 工作组主键
	 * @return 工作组主键查询下级岗位对象主键的集合
	 */
	@Transactional(readOnly = true)
	public List<Long> getPositionIdsByGroupId(Long groupId){
		if (groupId != null)
			return omPositionDao.getPositionIds(OrgConstant.PARTY_TYPE_GROUP, groupId);
		else
			return null;
	}

	/**
	 * 根据机构ID查询直属下级岗位
	 * @param OrgId 机构id
	 * @return 机构ID查询下级岗位对象集合
	 */
	@Transactional(readOnly = true)
	public List<OmPositionForm> getPositionsByOrgId(Long orgId) {
		if (orgId != null)
			return omPositionDao.getPositions(OrgConstant.PARTY_TYPE_ORG, orgId);
		else
			return null;
	}
	
	/**
	 * 根据工作组id查询下级岗位
	 * @author 王剑文
	 * @param groupId 工作组id
	 * @return 机构ID查询下级岗位对象集合
	 */
	@Transactional(readOnly = true)
	public List<OmPositionForm> getPositionsByGroupId(Long groupId){
		if(groupId != null){
			return omPositionDao.getPositions(OrgConstant.PARTY_TYPE_GROUP, groupId);
		}
		return null;
	}

	/**
	 * 根据机构ID查询下级岗位以及下级岗位的子岗位
	 * @param orgId 机构id
	 * @return 机构ID查询下级岗位对象集合
	 */
	@Transactional(readOnly = true)
	public List<OmPositionForm> getAllPositionsByOrgId(Long orgId) {
		if (orgId != null)
			return omPositionDao.getAllPositions(OrgConstant.PARTY_TYPE_ORG, orgId);
		else
			return null;
	}

	/**
	 * 根据机构ID删除下级岗位
	 * @param OrgId 机构id
	 */
	public void deletePosCascade(Long orgId) {
		List<Long> list = null;
		if (orgId != null) {

			// 1.先根据机构id找到下级岗位集合
			list = this.getPositionIdsByOrgId(orgId);

			// 2.把集合中的岗位节点循环删除
			if (list != null && list.size() > 0) {
				for (int i = 0; i < list.size(); i++) {
					this.deletePosition(list.get(i));
				}
			}
		}
	}

	/**
	 * 删除岗位以及所有子岗位，关联的用户
	 * @param posId 岗位主键
	 */
	public void deletePosition(Long posId) {
		if (posId != null) {

			// 获取所有子岗位,不包括本岗位
			List<OmPositionForm> list = this.getAllChildPositions(posId);
			if(list == null)
				list = new ArrayList<OmPositionForm>();
			list.add(this.get(posId));
			
			// 循环删除每个岗位和关联的用户
			if (list != null && list.size() > 0) {
				for (OmPositionForm form : list) {
					omUserPositionDao.deleteByPosId(form.getPosId());
					
					//TODO  删除和岗位关联的角色
					this.disAssociationRoleByPosId(form.getPosId());
					
					//删除前要处理父节点的关联
					if(form.getParentPosId() != null){
						omPositionDao.updatePositionAfterRemoveChildren(form.getParentPosId());
					}
					
					//删除自己
					omPositionDao.delete(form.getPosId());
				}
			}
		}  
	}
	
	

	/**
	 * 根据主键ID查询直属子岗位
	 * @param parentPosId 岗位对象主键
	 * @return 岗位对象主键的集合
	 */
	@Transactional(readOnly = true)
	public List<Long> getChildPositionIds(Long parentPosId) {
		if (parentPosId != null) {
			return omPositionDao.getChildPositions(parentPosId);
		} else
			return null;
	}

	/**
	 * 根据主键ID查询直属子岗位
	 * @param parentPosId 岗位对象主键
	 * @return 岗位对象主键的集合
	 */
	@Transactional(readOnly = true)
	public List<OmPositionForm> getChildPositions(Long parentPosId) {
		if (parentPosId != null) {
			return omPositionDao.getChildPositionForms(parentPosId);
		} else
			return null;
	}

	/**
	 * 根据主键ID分页查询直属子岗位
	 * @param parentPosId 岗位对象主键
	 * @return 岗位对象主键的集合
	 */
	@Transactional(readOnly = true)
	public Page<OmPositionForm> getChildPositions(Long parentPosId, Page<OmPositionForm> page) {
		if (parentPosId != null) {
			// 建立新的分页对象
			Page<OmPosition> pg = PageUtils.newPageInstance(page);

			String hql = "from OmPosition ps where ps.parentPosId = ?";
			omPositionDao.findPage(pg, hql, parentPosId);

			List<SysCodeForm> statusList = sysCodeService.getItems(OrgConstant.SYS_CODE_ORG_STATUS);
			
			// 转换为Form对象列表并赋值到原分页对象中
			List<OmPositionForm> list = OmPositionConverter
					.convertToFormList(pg.getResult(),statusList);
			PageUtils.copy(pg, list, page);
		}
		return page;
	}
	
	/**
	 * 根据主键ID通过岗位序列posSeq模糊查询所有的子岗位
	 * @param id 岗位对象主键
	 * @return 岗位对象的集合
	 */
	@Transactional(readOnly = true)
	public List<OmPositionForm> getAllChildPositions(Long parentPosId) {
		List<OmPositionForm> list = null;
		if (parentPosId != null) {
			list = omPositionDao.getAllChildPositionForms(parentPosId);
		}
		return list;
	}

	/**
	 * 获取指定组织下的岗位列表
	 * @param partyId
	 * @param posType
	 * @param page
	 * @return
	 */
	@Transactional(readOnly = true)
	private Page<OmPositionForm> getPositions(Long partyId, String posType, Page<OmPositionForm> page){
		if (partyId != null && page != null) {
			// 建立新的分页对象
			Page<OmPosition> pg = PageUtils.newPageInstance(page);

			String hql = "from OmPosition ps where ps.parentPosId=null and ps.posType=? and ps.partyId=?";
			omPositionDao.findPage(pg, hql, posType, partyId);
			
			List<SysCodeForm> statusList = sysCodeService.getItems(OrgConstant.SYS_CODE_ORG_STATUS);
			
			// 转换为Form对象列表并赋值到原分页对象中
			List<OmPositionForm> list = OmPositionConverter.convertToFormList(pg.getResult(),statusList);
			PageUtils.copy(pg, list, page);

			return page;
		}
		return null;
	}

	/**
	 * 分页获取指定机构的直属岗位列表
	 * @param orgId 机构ID
	 * @return
	 */
	@Transactional(readOnly = true)
	public Page<OmPositionForm> getPositionsByOrgId(Long orgId, Page<OmPositionForm> page) {
		if (orgId != null && page != null) {
			return getPositions(orgId, OrgConstant.PARTY_TYPE_ORG, page);
		}
		return null;
	}
	
	/**
	 * 分页获取指定工作组的直属岗位列表
	 * @param groupId 工作组ID
	 * @return
	 */
	@Transactional(readOnly = true)
	public Page<OmPositionForm> getPositionsByGroup(Long groupId, Page<OmPositionForm> page) {
		if (groupId != null && page != null) {
			return getPositions(groupId, OrgConstant.PARTY_TYPE_GROUP, page);
		}
		return null;
	}

	/**
	 * 移动岗位到另一机构节点下
	 * @param posId 岗位ID
	 * @param targetOrgId 用户所要移到的机构ID
	 */
	public void movePositionToOrg(Long posId, Long targetOrgId) {
		if (posId != null && targetOrgId != null) {
			OmPositionForm form = this.get(posId);

			// 获取本岗位的所有子岗位
			List<OmPositionForm> list = omPositionDao.getAllChildPositionForms(posId);

			// 修改所有子岗位节点的机构id
			omPositionDao.updateOrgIdAfterMovePosition(targetOrgId, list);

			// 修改本岗位节点机构id
			form.setPartyId(targetOrgId);
			this.save(form);

		}
	}

	/**
	 * 移动岗位到新父岗位节点下
	 * @param posId 岗位ID
	 * @param targetParentPosId 用户所要移到的新父岗位ID
	 */
	public void movePosition(Long posId, Long targetParentPosId) {

		if (posId != null && targetParentPosId != null) {

			// 更新原父岗位节点
			omPositionDao.updatePositionAfterRemoveChildren(posId);

			// 将本岗位节点的父节点改为目标岗位节点
			OmPosition entity = omPositionDao.get(posId);
			entity.setParentPosId(targetParentPosId);
			omPositionDao.save(entity);

			// 更新目标父机构节点
			omPositionDao.updatePositionAfterAddChildren(targetParentPosId);
		}
	}

	/**
	 * 为岗位装载用户
	 * @param form 岗位form对象 
	 */
	@Transactional(readOnly = true)
	public void loadUsers(OmPositionForm form) {
		if (form != null) {

			// 获取岗位的关联用户
			List<OmUserForm> users = omUserDao.getUsersByPosId(form.getPosId());

			// 装载用户
			if (users != null && users.size() != 0) {
				form.setUsers(users);
			}
		}
	}

	/**
	 * 为岗位list列表装载关联用户
	 * @param list 岗位列表
	 */
	@Transactional(readOnly = true)
	public void loadUsers(List<OmPositionForm> list) {
		if (list != null && list.size() > 0) {
			for (OmPositionForm form : list) {
				this.loadUsers(form);
			}
		}
	}


	/**
	 * 查询以组织id为partyId的所有岗位所关联的用户主键
	 * @param partyId 组织id
	 * @param posType 组织类型
	 * @return 用户主键列表
	 */
	@Transactional(readOnly = true)
	public List<Long> getHavePositionUsers(Long partyId, String posType) {
		List<Long> list = null;
		if (partyId != null) {
			String hql = "select distinct up.userId from OmPosition p,OmUserPosition up "
					+ "where up.posId=p.posId and p.posType=? and p.partyId=?";
			list = this.omUserPositionDao.find(hql, posType, partyId);
		}
		return list;
	}

	/**
	 * 根据岗位主键获取关联用户列表
	 * @param posId 岗位主键
	 * @return 岗位关联的用户列表
	 */
	@Transactional(readOnly = true)
	public List<OmUserForm> getUsersByPosId(Long posId) {
		return omUserDao.getUsersByPosId(posId);
	}
	
	/**
	 * 获取指定用户的岗位ID集合
	 * @param userId
	 * @return
	 */
	@Transactional(readOnly = true)
	public List<Long> getPositionIds(Long userId){
		return omUserPositionDao.getPostionIds(userId);
	}
	
	/** ****************分级授权方法************************** */

	/**
	 * 判断管理用户是否具有指定岗位的管理权限，分管理员为超级管理员和普通用户
	 * 2种情况判断，若拥有权限，则返回true，否则，返回false；
	 * @param adminUserId  管理用户主键
	 * @param posId 岗位主键
	 * @return 管理用户是否具有指定岗位的管理权限,若有，返回true，否则，返回false；
	 */
	@Transactional(readOnly = true)
	private boolean canManagePosition(Long adminUserId, Long posId) {
		boolean result = false;
		
		if (adminUserId != null && posId != null) {

			// 系统管理员
			if (omUserDao.isSystemAdmin(adminUserId))
				result = true;

			// 普通用户
			else {
				// 获取该管理用户的管理机构列表OrgIds
				List<Long> orgIds = omOrgDao.getCanManageOrgIds(adminUserId);

				// 查询机构列表OrgIds关联的岗位列表posIds
				List<Long> posIds = getPosIdsByOrgIds(orgIds);

				// 判断posId是否在posIds中
				result = posIds.contains(posId);
			}
		}
		
		return result;
	}

	/**
	 * 根据机构主键列表获取关联的岗位列表
	 * @param orgIds 机构主键列表
	 * @return 岗位列表
	 */
	@Transactional(readOnly = true)
	public List<Long> getPosIdsByOrgIds(List<Long> orgIds) {
		List<Long> posIds = null;
		
		if (orgIds != null && orgIds.size() > 0) {
			String hql = "select distinct ps.posId from OmPosition ps where 1=1 and ";
			hql += HqlUtils.buildOrCondition("ps", "orgId", CollectionUtils.toLongArray(orgIds));
			posIds = omPositionDao.find(hql);
		}
		
		return posIds;
	}

	/**
	 * 判断管理用户是否具有岗位列表的全部管理权限
	 * @param adminUserId 管理用户
	 * @param posIds 岗位主键或主键数组
	 * @return 若管理用户具有岗位列表的全部管理权限，返回true，否则，返回false；
	 */
	@Transactional(readOnly = true)
	public boolean canManagePosition(Long adminUserId, Long... posIds) {
		boolean result = false;
		if (adminUserId != null && posIds != null) {

			// 循环判断是否具有管理权限
			for (Long posId : posIds) {
				result = this.canManagePosition(adminUserId, posId);
				if (result == false)
					return result;// 只要一个岗位没有权限，则返回false
			}
		}
		return result;
	}

	/**
	 * 根据权限删除岗位列表，若管理用户拥有岗位列表的全部管理权限，则可以删除 否则，删除失败
	 */
	public ResultForm<Object> delete(Long adminUserId, Long... posIds) {
		ResultForm<Object> dto = new ResultForm<Object>(false);
		if (adminUserId != null && posIds != null) {
			if (this.canManagePosition(adminUserId, posIds))
				this.delete(posIds);
		}
		return null;
	}

	/**
	 * 根据机构id级联删除关联的岗位，根据用户权限先判断是否有权限删除
	 * @param userId 用户主键
	 * @param orgId  机构主键
	 * @return 是否成功删除的提示信息
	 */
	public ResultForm<Object> deletePosCascade(Long adminUserId, Long orgId) {
		ResultForm<Object> dto = new ResultForm<Object>(false);
		if (adminUserId != null && orgId != null) {

			// 有管理权限
			if (omUserDao.isSystemAdmin(adminUserId)
					|| this.omOrgDao.isOrgAdmin(adminUserId, orgId)) {
				this.deletePosCascade(orgId);
				dto.setSuccess(true);
			}

			// 没有管理权限
			else
				MsgUtils.addNoPositionPrivilegeError(dto);
		}
		return dto;
	}

	/**
	 * 管理用户拥有岗位的管理权限时，根据岗位对象获取岗位form对象
	 * @param adminUserId
	 * @param posId
	 * @return  若成功执行，返回岗位form对象，否则返回失败信息
	 */
	@Transactional(readOnly = true)
	public ResultForm<OmPositionForm> get(Long adminUserId, Long posId) {
		ResultForm<OmPositionForm> dto = new ResultForm<OmPositionForm>(false);
		if (adminUserId != null && posId != null) {

			// 有权限
			if (this.canManagePosition(adminUserId, posId)) {
				this.get(posId);
			}

			// 没有权限
			else
				MsgUtils.addNoPositionPrivilegeError(dto);

		}
		return dto;
	}

	/**
	 * 根据机构id获取关联的所有岗位，先要判断管理用户是否拥有该机构的管理权限
	 * @param adminUserId 管理用户主键
	 * @param orgId 机构主键
	 * @return 是否成功执行查询的信息
	 */
	@Transactional(readOnly = true)
	public ResultForm<List<OmPositionForm>> getAllPositions(Long adminUserId,Long orgId) {
		ResultForm<List<OmPositionForm>> result = new ResultForm(false);
		
		if (adminUserId != null && orgId != null) {

			// 有权限
			if (omUserDao.isSystemAdmin(adminUserId)
					|| this.omOrgDao.isOrgAdmin(adminUserId, orgId)) {
				this.getAllPositionsByOrgId(orgId);
				result.setSuccess(true);
			}

			// 没有权限
			else
				MsgUtils.addNoOrgPrivilegeError(result);

		}
		return result;
	}

	/**
	 * 根据机构主键获取机构的直属岗位列表
	 * @param adminUserId  管理用户主键
	 * @param orgId 机构主键
	 * @return 机构的直属岗位列表
	 */
	@Transactional(readOnly = true)
	public ResultForm<List<OmPositionForm>> getPositions(Long adminUserId, Long orgId) {
		ResultForm<List<OmPositionForm>> result = new ResultForm(false);
		
		if (adminUserId != null && orgId != null) {

			// 有权限
			if (omUserDao.isSystemAdmin(adminUserId)
					|| this.omOrgDao.isOrgAdmin(adminUserId, orgId)) {
				this.getPositionsByOrgId(orgId);
				result.setSuccess(true);
			}

			// 没有权限
			else
				MsgUtils.addNoOrgPrivilegeError(result);

		}
		return result;
	}

	/**
	 * 根据岗位获取关联用户列表，先判断管理用户是否拥有管理权限,
	 * 若有权限，返回关联用户列表和执行成功的信息；否则，返回失败信息
	 * @param adminUserId 管理用户主键
	 * @param posId 岗位主键
	 * @return 
	 */
	@Transactional(readOnly = true)
	public ResultForm<List<OmUserForm>> getUsersByPosId(Long adminUserId, Long posId) {
		ResultForm<List<OmUserForm>> result = new ResultForm(false);
		
		if (adminUserId != null && posId != null) {

			// 有权限
			if (this.canManagePosition(adminUserId, posId)) {
				result.setResult(omUserDao.getUsersByPosId(posId));
				result.setSuccess(true);
			}

			// 没有权限
			else
				MsgUtils.addNoPositionPrivilegeError(result);

		}
		return result;
	}

	/**
	 * 将岗位移动到目标岗位下，需要判断管理用户是否同时具有该岗位和目标岗位的管理权限，
	 * 若是，则可以移动，否则，移动失败，返回失败信息
	 * @param adminUserId 管理用户
	 * @param posId 要移动的岗位主键
	 * @param targetParentPosId 要移动的目标岗位主键
	 * @return
	 */
	public ResultForm<Object> movePosition(Long adminUserId, Long posId, Long targetParentPosId) {
		ResultForm<Object> result = new ResultForm(false);
		
		if(adminUserId != null && posId != null && targetParentPosId != null){
			
			//管理用户拥有本岗位的管理权限
			if(this.canManagePosition(adminUserId, posId)){
				
				//管理用户拥有目标父岗位的管理权限
				if(this.canManagePosition(adminUserId, targetParentPosId)){
					this.movePosition(posId, targetParentPosId);
					result.setSuccess(true);
				}
				
				//没有管理用户拥有目标父岗位的管理权限
				else
					MsgUtils.addNoParentPositionPrivilegeError(result);
			}
			
			//没有管理用户拥有本岗位的管理权限
			else
				MsgUtils.addNoPositionPrivilegeError(result);
					
		}
		return null;
	}

	/**
	 * 将岗位移动到目标机构下，需要判断管理用户是否同时具有该岗位和目标机构的管理权限，
	 * 若是，则可以移动，否则，移动失败，返回失败信息
	 * @param adminUserId 管理用户
	 * @param posId 要移动的岗位主键
	 * @param targetOrgId 要移动到的目标机构主键
	 * @return
	 */
	public ResultForm<Object> movePositionToOrg(Long adminUserId, Long posId, Long targetOrgId) {
		ResultForm<Object> result =  new ResultForm(false);
		
		//拥有岗位的管理权限
		if(this.canManagePosition(adminUserId, posId)){
			
			//拥有机构的管理权限
			if(omUserDao.isSystemAdmin(adminUserId) 
					|| omOrgDao.isOrgAdmin(adminUserId, targetOrgId)){
				this.movePositionToOrg(posId, targetOrgId);
				result.setSuccess(true);
			}
			
			else
				MsgUtils.addNoOrgPrivilegeError(result);
		}
		
		//没有岗位的管理权限
		else
			MsgUtils.addNoPositionPrivilegeError(result);
		return null;
	}

	/**
	 * 保存岗位form对象列表，若有管理用户对岗位列表对象全部具有管理权限，则执行保存，
	 * 否则，返回失败信息
	 * @param adminUserId 管理用户主键
	 * @param forms 岗位form对象列表
	 * @return  
	 */
	public ResultForm<Object> save(Long adminUserId, OmPositionForm... forms) {
		ResultForm<Object> result = new ResultForm(false);
		
		if (adminUserId != null && forms != null) {
			
			Long [] posIds = OrgUtils.convertPosFormsToIds(forms);
			// 有权限
			if (this.canManagePosition(adminUserId, posIds)) {
				this.save(forms);
				result.setSuccess(true);
			}

			// 没有权限
			else
				MsgUtils.addNoPositionPrivilegeError(result);

		}
		return result;
	}
	
	/**
	 * 根据岗位主键列表获取所有的关联用户主键列表
	 * @param posIds 岗位主键列表
	 * @return 所有的关联用户主键列表
	 */
	@Transactional(readOnly = true)
	public List<Long> getUserIdsByPosIds(List<Long> posIds){
		if(posIds !=null){
			String hql = "select distinct u.userId from OmUser u,OmUserPosition up where up.userId=u.userId";
			
			if(posIds != null && posIds.size() > 0){
				hql += " and " + HqlUtils.buildOrCondition("up", "posId", CollectionUtils.toLongArray(posIds));
			}
						
			return omUserPositionDao.find(hql);
		}
		return null;
	}

	/**
	 * 根据岗位id获取岗位对象，包括扩展属性children,users
	 */
	@Transactional(readOnly = true)
	public OmPositionForm getPosRelateElement(Long posId){
		OmPositionForm form = this.get(posId);
		form.setChildren(this.getChildPositions(posId));
		form.setUsers(omUserDao.getUsersByPosId(posId));
		return form;
	}
	
	/**
	 * 删除岗位关联的角色
	 */
	public void disAssociationRoleByPosId(Long posId){
		if(posId != null){
			List<AcRoleForm> list = acRoleDao.getRolesByPosId(posId);
			if(list != null && list.size() >0){
				for(AcRoleForm form :list)
					this.partyRoleDao.disAssociateRoleFromPos(form.getRoleId(), posId);
			}
		}
	}

	/**
	 * 保存OmPositionForm，还要建立好它跟父岗位的关联
	 */
	public void savePosCascade(OmPositionForm form){
		if(form != null){
			//修改
			if(form.getPosId() != null){
				this.save(form);
			}
			
			//增加
			else{
				if(form.getSubCount()==null)
					form.setSubCount(0);
				
				//保存对象，获得主键
				this.save(form);
				
				//父节subCount属性+1
				this.omPositionDao.updatePositionAfterAddChildren(form.getParentPosId());
				
				//设置本节点序列orgSeq
				String newOrgSeq = omPositionDao.getPosSeqAfterSavePos(form);
				form.setPosSeq(newOrgSeq);
			
				this.save(form);
			}
		}
	}
	
	/**
	 * 获取所有的岗位OmPositionForm列表
	 */
	@Transactional(readOnly = true)
	public List<OmPositionForm> getAll(){
		List<OmPosition> list = this.omPositionDao.getAll();
		if(list != null && list.size()>0)
			return OmPositionConverter.convertToFormList(list);
		else
			return null;
	}
	
	/**
	 * 根据指定岗位数组获取对应的用户id数组
	 * @param posIds 岗位id数组
	 * @return 用户id数组
	 */
	@Transactional(readOnly = true)
	public Long[] getUserIdsByPosIds(Long[] posIds){
		if(posIds != null && posIds.length > 0){
			return omUserPositionDao.getUserIdsByPosIds(posIds);
		}
		return null;
	}
	
	/**
	 * 删除用户在该机构下的岗位
	 * @param userId 用户主键
	 * @param orgId 机构主键
	 */
	public void deleteUserPosOfCurOrg(Long userId, Long orgId){
		//获取用户的岗位表
		List<OmUserPosition> userPoses = omUserPositionDao.getByUserId(userId);
		
		if(userPoses != null && userPoses.size() > 0){
			//对于该用户下的每个岗位
			for(OmUserPosition omUserPosition:userPoses){
				Long posId = omUserPosition.getPosId();
				
				OmPositionForm form = this.get(posId);
				//如果是机构岗位
				if(form.getPosType().equals(OrgConstant.PARTY_TYPE_ORG) ){
					
					//获取岗位的隶属机构
					OmOrg parentOrgOfPos = omOrgDao.get(form.getPartyId());
					//获取当前机构
					OmOrg curOrg = omOrgDao.get(orgId);
					
					if(parentOrgOfPos != null && curOrg != null){
						//如果岗位的隶属机构是当前机构的子机构
						if(parentOrgOfPos.getOrgSeq().indexOf(curOrg.getOrgSeq()) >= 0){
							omUserPositionDao.delete(omUserPosition);
						}
					}
				}
			}
		}
	}
	
	/**
	 * 删除用户在该工作组下的岗位
	 * @param userId 用户主键
	 * @param groupId 工作组主键
	 */
	public void deleteUserPosOfCurGroup(Long userId, Long groupId){
		//获取用户的岗位表
		List<OmUserPosition> userPoses = omUserPositionDao.getByUserId(userId);
		
		if(userPoses != null && userPoses.size() > 0){
			//对于该用户下的每个岗位
			for(OmUserPosition omUserPosition:userPoses){
				Long posId = omUserPosition.getPosId();
				
				OmPositionForm form = this.get(posId);
				//如果是机构岗位
				if(form.getPosType().equals(OrgConstant.PARTY_TYPE_GROUP) ){
					
					//获取岗位的隶属机构
					OmGroup parentOrgOfPos = omGroupDao.get(form.getPartyId());
					//获取当前机构
					OmGroup curOrg = omGroupDao.get(groupId);
					
					if(parentOrgOfPos != null && curOrg != null){
						//如果岗位的隶属机构是当前机构的子机构
						if(parentOrgOfPos.getGroupSeq().indexOf(curOrg.getGroupSeq()) >= 0){
							omUserPositionDao.delete(omUserPosition);
						}
					}
				}
			}
		}
	}
	
	/**
	 * 根据posCode获取form对象
	 * @param posCode
	 * @return
	 */
	@Transactional(readOnly = true)
	public OmPositionForm getByPosCode(String posCode){
		OmPositionForm form = null;
		if(posCode != null && posCode.trim().length()>0){
			String hql = "from OmPosition ps where ps.posCode='"+posCode+"'";
			List<OmPosition> list = this.partyRoleDao.find(hql);
			if(list != null && list.size()>0){
				OmPosition entity = list.get(0);
				form = OmPositionConverter.convertToForm(entity);
			}
		}
		return form;
	}
	
	/**
	 * 判断一个岗位以及岗位下的子岗位,用户是否匹配
	 * @param posId
	 * @param keyword
	 * @return
	 */
	public boolean isPosLikeKeyword(Long posId,String keyword){
		if(posId != null && keyword != null && keyword.trim().length()>0){
			OmPositionForm form = this.get(posId);
			if(isLikeKeyword(form,keyword))
				return true;
			else{
				List<OmPositionForm> posList = this.getAllChildPositions(posId);
				if(isLikeKeyword(posList,keyword)){
					return true;
				}
				else{
					if(posList == null)
						posList = new ArrayList<OmPositionForm>();
					posList.add(form);
					List<OmUserForm> userList = this.omUserService.getUserByposListAndKeyword(posList, keyword);
					if(userList != null && userList.size()>0)
						return true;
				}
			}
				
		}
		return false;
	}
	
	/**
	 * 
	 * @param orgList
	 * @param keyword
	 * @return
	 */
	public boolean isOrgListPosLikeKeyword(List<OmOrgForm>orgList,String keyword){
		if(orgList != null && orgList.size()>0 && keyword != null && keyword.trim().length()>0){
			List<OmPositionForm> posList = omPositionDao.getPosByOrgListAndKeyword(orgList,keyword);
			
			if(posList != null && posList.size()>0){
				for(OmPositionForm form:posList){
					if(isPosLikeKeyword(form.getPosId(),keyword))
						return true;
				}
			}
		}
		return false;
	}
	

	public boolean isLikeKeyword(List<OmPositionForm>list,String keyword){
		boolean bool =  false;
		if(list != null &&list.size()>0 && keyword != null && keyword.trim().length()>0){
			for(OmPositionForm form :list){
				if(isLikeKeyword(form,keyword))
					return true;
			}
		}
		return bool;
	}
	
	public boolean isLikeKeyword(OmPositionForm form,String keyword){
		boolean bool =  false;
		if(form != null && keyword != null && keyword.trim().length()>0){
			if(form.getPosName().length()>=keyword.length()){
				String subStr = form.getPosName().substring(0, keyword.length());
				if(subStr.equals(keyword))
					return true;
			}
		}
		return bool;
	}
	
	//判断岗位表中是否有匹配的记录
	public boolean hasPosLikeKeyword(List<OmPositionForm>list,String keyword){
		if(keyword != null && keyword.trim().length()>0 && list != null && list.size()>0)
			for(OmPositionForm form:list){
				if(isPosLikeKeyword(form.getPosId(),keyword))
					return true;
			}
		return false;
	}
}
